package com.example.hrsystem.workflow.engine;

import android.util.Log;

import com.example.hrsystem.workflow.model.ProcessDefinition;
import com.example.hrsystem.workflow.model.ProcessInstance;
import com.example.hrsystem.workflow.model.WorkflowTask;
import com.example.hrsystem.workflow.repository.WorkflowRepository;

import java.util.Date;
import java.util.List;
import java.util.Random;

/**
 * 工作流引擎核心类
 * 负责流程的启动、执行、任务处理等核心功能
 */
public class WorkflowEngine {
    private static final String TAG = "WorkflowEngine";
    private WorkflowRepository workflowRepository;

    public WorkflowEngine(WorkflowRepository workflowRepository) {
        this.workflowRepository = workflowRepository;
    }

    /**
     * 启动一个新的流程实例
     *
     * @param processDefinitionId 流程定义ID
     * @param initiatorId         发起人ID
     * @return 新创建的流程实例
     */
    public ProcessInstance startProcess(int processDefinitionId, int initiatorId) {
        ProcessDefinition processDefinition = workflowRepository.getProcessDefinitionById(processDefinitionId);
        if (processDefinition == null) {
            throw new IllegalArgumentException("流程定义不存在");
        }

        // 创建流程实例
        ProcessInstance processInstance = new ProcessInstance();
        processInstance.setProcessDefinitionId(processDefinitionId);
        processInstance.setInstanceKey("PI-" + System.currentTimeMillis()); // 简单的唯一标识符
        processInstance.setName(processDefinition.getName());
        processInstance.setStatus("ACTIVE");
        processInstance.setInitiatorId(initiatorId);
        processInstance.setStartTime(new java.util.Date());

        // 保存流程实例
        workflowRepository.saveProcessInstance(processInstance);

        // 创建第一个任务（简化实现，实际应该解析流程定义）
        WorkflowTask firstTask = new WorkflowTask();
        firstTask.setProcessInstanceId(processInstance.getId());
        firstTask.setName("初始任务");
        firstTask.setDescription("流程的第一个任务");
        firstTask.setStatus("PENDING");
        firstTask.setCreateTime(new java.util.Date());

        // 简化实现：随机分配处理人
        java.util.Random random = new java.util.Random();
        firstTask.setAssigneeId(1000 + random.nextInt(100)); // 假设用户ID在1000-1100之间

        // 保存任务
        workflowRepository.saveTask(firstTask);

        Log.d(TAG, "启动流程实例: " + processInstance.getInstanceKey());
        return processInstance;
    }

    /**
     * 处理任务（完成或拒绝）
     *
     * @param taskId     任务ID
     * @param action     操作类型 (COMPLETE/REJECT)
     * @param userId     处理用户ID
     * @param comment    处理意见
     * @return 更新后的流程实例
     */
    public ProcessInstance handleTask(int taskId, String action, int userId, String comment) {
        WorkflowTask task = workflowRepository.getTaskById(taskId);
        if (task == null) {
            throw new IllegalArgumentException("任务不存在");
        }

        // 验证用户权限
        if (!task.getAssigneeId().equals(userId)) {
            throw new SecurityException("无权限处理此任务");
        }

        ProcessInstance processInstance = workflowRepository.getProcessInstanceById(task.getProcessInstanceId());
        if (processInstance == null) {
            throw new IllegalStateException("关联的流程实例不存在");
        }

        // 更新任务状态
        if ("COMPLETE".equals(action)) {
            task.setStatus("COMPLETED");
            task.setCompleteTime(new java.util.Date());
        } else if ("REJECT".equals(action)) {
            task.setStatus("REJECTED");
            task.setCompleteTime(new java.util.Date());
        } else {
            throw new IllegalArgumentException("无效的操作类型");
        }

        // 保存任务更新
        workflowRepository.updateTask(task);

        // 检查是否是最后一个任务
        if (isLastTask(processInstance)) {
            processInstance.setStatus("COMPLETED");
            processInstance.setEndTime(new java.util.Date());
            workflowRepository.updateProcessInstance(processInstance);
        } else if ("REJECT".equals(action)) {
            // 如果是拒绝操作，终止流程
            processInstance.setStatus("TERMINATED");
            processInstance.setEndTime(new java.util.Date());
            workflowRepository.updateProcessInstance(processInstance);
        } else {
            // 创建下一个任务（简化实现）
            createNextTask(processInstance, task);
        }

        Log.d(TAG, "处理任务: " + task.getName() + ", 操作: " + action);
        return processInstance;
    }

    /**
     * 检查是否是最后一个任务
     *
     * @param processInstance 流程实例
     * @return 是否是最后一个任务
     */
    private boolean isLastTask(ProcessInstance processInstance) {
        // 简化实现：随机返回true/false
        java.util.Random random = new java.util.Random();
        return random.nextBoolean();
    }

    /**
     * 处理条件分支
     *
     * @param processInstance 流程实例
     * @param currentTask     当前任务
     * @param condition       条件表达式
     */
    private void handleConditionalGateway(ProcessInstance processInstance, WorkflowTask currentTask, String condition) {
        // 简化实现：根据条件创建不同的后续任务
        if ("amount > 1000".equals(condition)) {
            // 创建需要高级审批的任务
            createAdvancedApprovalTask(processInstance, currentTask);
        } else {
            // 创建普通审批任务
            createNormalApprovalTask(processInstance, currentTask);
        }
    }

    /**
     * 处理并行网关
     *
     * @param processInstance 流程实例
     * @param currentTask     当前任务
     */
    private void handleParallelGateway(ProcessInstance processInstance, WorkflowTask currentTask) {
        // 创建并行任务
        createParallelTask(processInstance, currentTask, "财务审批");
        createParallelTask(processInstance, currentTask, "人事审批");
    }

    /**
     * 创建高级审批任务
     *
     * @param processInstance 流程实例
     * @param previousTask    前一个任务
     */
    private void createAdvancedApprovalTask(ProcessInstance processInstance, WorkflowTask previousTask) {
        WorkflowTask task = new WorkflowTask();
        task.setProcessInstanceId(processInstance.getId());
        task.setName("高级审批");
        task.setDescription("需要高级管理层审批");
        task.setStatus("PENDING");
        task.setCreateTime(new java.util.Date());

        // 简化实现：固定分配给高级管理人员
        task.setAssigneeId(1003); // 假设高级管理人员ID为1003

        workflowRepository.saveTask(task);
    }

    /**
     * 创建普通审批任务
     *
     * @param processInstance 流程实例
     * @param previousTask    前一个任务
     */
    private void createNormalApprovalTask(ProcessInstance processInstance, WorkflowTask previousTask) {
        WorkflowTask task = new WorkflowTask();
        task.setProcessInstanceId(processInstance.getId());
        task.setName("普通审批");
        task.setDescription("普通管理层审批");
        task.setStatus("PENDING");
        task.setCreateTime(new java.util.Date());

        // 简化实现：随机分配处理人
        java.util.Random random = new java.util.Random();
        task.setAssigneeId(1000 + random.nextInt(100)); // 假设用户ID在1000-1100之间

        workflowRepository.saveTask(task);
    }

    /**
     * 创建并行任务
     *
     * @param processInstance 流程实例
     * @param previousTask    前一个任务
     * @param taskName        任务名称
     */
    private void createParallelTask(ProcessInstance processInstance, WorkflowTask previousTask, String taskName) {
        WorkflowTask task = new WorkflowTask();
        task.setProcessInstanceId(processInstance.getId());
        task.setName(taskName);
        task.setDescription(taskName + "任务");
        task.setStatus("PENDING");
        task.setCreateTime(new java.util.Date());

        // 简化实现：随机分配处理人
        java.util.Random random = new java.util.Random();
        task.setAssigneeId(1000 + random.nextInt(100)); // 假设用户ID在1000-1100之间

        workflowRepository.saveTask(task);
    }

    /**
     * 创建下一个任务
     *
     * @param processInstance 流程实例
     * @param previousTask    前一个任务
     */
    private void createNextTask(ProcessInstance processInstance, WorkflowTask previousTask) {
        // 检查是否有条件分支或并行网关配置
        // 这里简化实现，实际应该从流程定义中读取配置
        String gatewayType = "normal"; // 可能的值："conditional", "parallel", "normal"
        String condition = ""; // 条件表达式，用于条件分支

        switch (gatewayType) {
            case "conditional":
                handleConditionalGateway(processInstance, previousTask, condition);
                break;
            case "parallel":
                handleParallelGateway(processInstance, previousTask);
                break;
            default:
                // 创建普通的下一个任务
                WorkflowTask task = new WorkflowTask();
                task.setProcessInstanceId(processInstance.getId());
                task.setName("后续任务");
                task.setDescription("流程的后续任务");
                task.setStatus("PENDING");
                task.setCreateTime(new java.util.Date());

                // 简化实现：随机分配处理人
                java.util.Random random = new java.util.Random();
                task.setAssigneeId(1000 + random.nextInt(100)); // 假设用户ID在1000-1100之间

                // 保存任务
                workflowRepository.saveTask(task);
                break;
        }
    }

    /**
     * 处理任务
     *
     * @param taskId 任务ID
     * @param assigneeId 处理人ID
     * @param action 处理动作 (COMPLETE, REJECT等)
     * @return 处理结果
     */
    public boolean handleTask(int taskId, int assigneeId, String action) {
        WorkflowTask task = workflowRepository.getTaskById(taskId);
        // 检查任务是否属于当前处理人
        if (task.getAssigneeId() != null && task.getAssigneeId() != assigneeId) {
            Log.d(TAG, "Task " + task.getId() + " 不属于当前处理人 " + assigneeId);
            return false;
        }
        switch (action) {
            case "COMPLETE":
                completeTask(task);
                break;
            case "REJECT":
                rejectTask(task);
                break;
            default:
                return false;
        }

        return true;
    }

    /**
     * 获取用户的待办任务列表
     *
     * @param userId 用户ID
     * @return 待办任务列表
     */
    public List<WorkflowTask> getUserTasks(int userId) {
        return workflowRepository.getTasksByAssignee(userId);
    }

    /**
     * 获取流程实例的详细信息
     *
     * @param instanceId 流程实例ID
     * @return 流程实例
     */
    public ProcessInstance getProcessInstance(int instanceId) {
        return workflowRepository.getProcessInstanceById(instanceId);
    }

    /**
     * 生成流程实例唯一标识符
     *
     * @return 流程实例key
     */
    private String generateInstanceKey() {
        return "PI_" + System.currentTimeMillis() + "_" + (int) (Math.random() * 1000);
    }

    /**
     * 初始化流程的第一个任务
     *
     * @param processInstance 流程实例
     */
    private void initializeFirstTask(ProcessInstance processInstance) {
        // 简化实现，实际应该解析流程定义找到起始节点
        WorkflowTask firstTask = new WorkflowTask();
        firstTask.setProcessInstanceId(processInstance.getId());
        firstTask.setName("初始任务");
        firstTask.setDescription("流程的第一个任务");
        firstTask.setStatus("PENDING");
        firstTask.setCreateTime(new java.util.Date());
        
        // 保存任务
        workflowRepository.saveTask(firstTask);
    }

    /**
     * 完成任务
     *
     * @param task 任务对象
     */
    private void completeTask(WorkflowTask task) {
        task.setStatus("COMPLETED");
        task.setCompleteTime(new java.util.Date());
        workflowRepository.updateTask(task);
        
        // 检查是否需要创建下一个任务
        createNextTaskIfNeeded(task);
    }

    /**
     * 拒绝任务
     *
     * @param task 任务对象
     */
    private void rejectTask(WorkflowTask task) {
        task.setStatus("REJECTED");
        workflowRepository.updateTask(task);
    }

    /**
     * 根据当前任务完成情况创建下一个任务
     *
     * @param completedTask 已完成的任务
     */
    private void createNextTaskIfNeeded(WorkflowTask completedTask) {
        // 简化实现，实际应该解析流程定义找到下一个节点
        ProcessInstance processInstance = workflowRepository.getProcessInstanceById(completedTask.getProcessInstanceId());
        if (processInstance != null) {
            // 检查是否是最后一个任务
            if (isLastTask(completedTask)) {
                // 结束流程
                processInstance.setStatus("COMPLETED");
                processInstance.setEndTime(new java.util.Date());
                workflowRepository.updateProcessInstance(processInstance);
            } else {
                // 创建下一个任务
                WorkflowTask nextTask = new WorkflowTask();
                nextTask.setProcessInstanceId(completedTask.getProcessInstanceId());
                nextTask.setName("下一步任务");
                nextTask.setDescription("流程的下一个任务");
                nextTask.setStatus("PENDING");
                nextTask.setCreateTime(new java.util.Date());
                
                // 保存任务
                workflowRepository.saveTask(nextTask);
            }
        }
    }

    /**
     * 判断是否是最后一个任务
     *
     * @param task 当前任务
     * @return 是否是最后一个任务
     */
    private boolean isLastTask(WorkflowTask task) {
        // 简化实现，实际应该解析流程定义判断
        java.util.Random random = new java.util.Random();
        return random.nextBoolean();
    }
}